home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-02 / tp6dv.zip / DV.PAS < prev    next >
Pascal/Delphi Source File  |  1992-02-08  |  16KB  |  575 lines
  1. {
  2. ********************************************************************
  3. *                                                                  *
  4. *  DESQview API routines                                           *
  5. *  for Turbo Pascal 6.0                                            *
  6. *  by Jonathan L. Zarate                                           *
  7. *  Released to the Public Domain                                   *
  8. *                                                                  *
  9. ********************************************************************
  10. }
  11. {
  12.   ** Please refer to Ralf Brown's Interrupt List
  13.   ** for additional information.
  14. }
  15.  
  16. Unit DV;
  17.  
  18. Interface
  19.  
  20. Type
  21.  Msg_Write2 = record
  22.                len : longint;
  23.                str : pointer;
  24.               end;
  25.  Msg_Write2_NewWin = record
  26.                       len    : longint;
  27.                       str    : pointer;
  28.                       handle : pointer;
  29.                      end;
  30.  
  31. const
  32. { Stream Types }
  33.  WinStream     = $00;
  34.  QueryStream   = $01;
  35.  ManagerStream = $10;
  36.  
  37. { Manager Streams }
  38.  MStream_MoveHoriz    = $00;     { horizontal movement  }
  39.  MStream_MoveVert     = $01;     { vertical movement  }
  40.  MStream_ChangeWidth  = $02;     { width change  }
  41.  MStream_ChangeHeight = $03;     { height change  }
  42.  MStream_ScrollHoriz  = $04;     { horizontal scroll  }
  43.  MStream_ScrollVert   = $05;     { vertical scroll  }
  44.  MStream_CloseWindow  = $06;     { close window option }
  45.  MStream_HideWindow   = $07;     { hide window option }
  46.  MStream_FreezeApp    = $08;     { freeze window option }
  47.  MStream_ScissorsMenu = $0E;     { scissors menu }
  48.  MStream_MainMenu     = $10;     { main DESQview menu }
  49.  MStream_SwitchWinMenu= $11;     { switch windows menu }
  50.  MStream_OpenWinMenu  = $12;     { open windows menu }
  51.  MStream_QuitMenu     = $13;     { quit menu }
  52.  
  53. { Window/Query streams }
  54.  WStream_CursorRow    = $A0;     { Cursor row }
  55.  WStream_CursorColumn = $A1;     { Cursor Column }
  56.  WStream_ScrollTopRow = $A2;     { Top row of scrolling region }
  57.  
  58. { DVError Constants }
  59.  DVErrorMouEither   = 00;        { use either mouse buttons to remove window }
  60.  DVErrorMouRight    = 32;        { use right mouse button to remove window }
  61.  DVErrorMouLeft     = 64;        { use left mouse button to remove window }
  62.  DVErrorBeep        = 128;       { beep on error }
  63. { ----------------------- }
  64.  
  65. const
  66.  InDV        : boolean = false;  { In DESQview flag }
  67.  DV_Version  : word = $0000;     { DESQview version }
  68.  
  69. var
  70.  DVArray     : array[1..80] of byte; { stream array }
  71.  
  72. function  DVInit : pointer;
  73. procedure DVGetVersion;
  74. function  DVGetShadowSeg( VideoSeg : word ) : word;
  75. procedure DVPause;
  76. procedure DVBeginC;
  77. procedure DVEndC;
  78. function  DVAPPNum : word;
  79. procedure DVSendMsg( Handle : pointer; _bh, _bl : byte; size : word; var param );
  80. procedure DVStream( Handle : pointer; mode : byte; params : string );
  81. function  DVGetHandle( HandleType : byte ) : pointer;
  82. procedure DVSound( Handle : pointer; frequency, duration : word );
  83. procedure DVError( Handle : pointer; xsize, ysize : byte; msg : string; params : byte );
  84. procedure DVAPILevel( major, minor : byte );
  85. procedure DVWrite( Handle : pointer; s : string );
  86. procedure DVWriteln( Handle : pointer; s : string );
  87. function  DVNewWin( x, y : word ) : pointer;
  88. procedure DVFree( var Handle : pointer );
  89. function  DVTimer_New : pointer;
  90. procedure DVTimer_Start( Handle : pointer; Time : longint );
  91. function  DVTimer_Len( Handle : pointer ) : longint;
  92. { ---- Window Streams ---- }
  93. procedure DVClear( Handle : pointer );
  94. procedure DVRedraw( Handle : pointer );
  95. procedure DVResize( Handle : pointer; x, y : byte );
  96. procedure DVMove( Handle : pointer; x, y : shortint );
  97. procedure DVTitle( Handle : pointer; title : string );
  98. procedure DVMove2( Handle : pointer; x, y : shortint );
  99. procedure DVResize2( Handle : pointer; x, y : shortint );
  100. procedure DVSetAttr( Handle : pointer; color : byte );
  101. procedure DVFrameAttr( Handle : pointer; color : byte );
  102. procedure DVFrameOn( Handle : pointer; b : boolean );
  103. procedure DVWinUnHide( Handle : pointer );
  104. procedure DVWinHide( Handle : pointer );
  105. procedure DVGotoXY( Handle : pointer; x, y : byte );
  106. procedure DVSetVirtualWinSize( Handle : pointer; x, y : byte );
  107. { -- Manager Streams -- }
  108. procedure DVAllow( Handle : pointer; command : byte );
  109. procedure DVDisallow( Handle : pointer; command : byte );
  110. procedure DVForeOnly( Handle : pointer; b : boolean );
  111. procedure DVMinWinSize( Handle : pointer; x, y : byte );
  112. procedure DVMaxWinSize( Handle : pointer; x, y : byte );
  113. procedure DVForceForeground( Handle : pointer );
  114. procedure DVForceBackground( Handle : pointer );
  115. procedure DVTopProcess( Handle : pointer );
  116. procedure DVBottomProcess( Handle : pointer );
  117. { ---- Query Streams ---- }
  118. procedure DVQSize( Handle : pointer; var x, y : byte );
  119. procedure DVQPos( Handle : pointer; var x, y : shortint );
  120. procedure DVQVirtualWinSize( Handle : pointer; var x, y : byte );
  121. function  DVWhereX( Handle : pointer ) : shortint;
  122. function  DVWhereY( Handle : pointer ) : shortint;
  123.  
  124. Implementation
  125.  
  126. function DVInit : pointer;
  127. begin
  128.  { get DESQview version & get our window handle }
  129.  DVGetVersion;
  130.  if InDV then DVInit:=DVGetHandle(1);
  131. end;
  132.  
  133. procedure DVGetVersion; assembler;
  134. asm
  135.  { get DESQview version/set InDV flag }
  136.  mov cx,'DE'
  137.  mov dx,'SQ'
  138.  mov ax,2b01h
  139.  int 21h
  140.  cmp al,0ffh
  141.  je @GV1
  142.  mov DV_Version,bx
  143.  mov InDV,True
  144.  jmp @GV2
  145. @GV1:
  146.  mov InDV,False
  147. @GV2:
  148. end;
  149.  
  150. function DVGetShadowSeg( VideoSeg : word ) : word; assembler;
  151. asm
  152.  { get task's shadow buffer & start shadowing }
  153.  mov ax,VideoSeg
  154.  mov es,ax
  155.  mov di,0
  156.  mov ah,0feh
  157.  int 10h
  158.  mov ax,es
  159.  { di=offset ??don't know if used?? }
  160. end;
  161.  
  162. procedure DVPause; assembler;
  163. asm
  164.  { give up CPU time }
  165.  mov ax,1000h
  166.  int $15
  167. end;
  168.  
  169. procedure DVBeginC; assembler;
  170. asm
  171.  { begin critical region }
  172.  mov ax,101bh
  173.  int $15
  174. end;
  175.  
  176. procedure DVEndC; assembler;
  177. asm
  178.  { end critical region }
  179.  mov ax,101ch
  180.  int $15
  181. end;
  182.  
  183. function DVAPPNum : word; assembler;
  184. asm
  185.  { get application's switch number }
  186.  mov ax,0de07h
  187.  int 15h
  188. end;
  189.  
  190. procedure DVSendMsg( Handle : pointer; _BH, _BL : byte;
  191.                       size : word; var param ); assembler;
  192. asm
  193.  std           { string goes backwards }
  194.  mov dx,sp     { save sp }
  195.  
  196.  mov cx,size   { load size of param }
  197.  jcxz @SM2     { if zero then don't push anything }
  198.  
  199.  mov bx,ds     { save ds }
  200.  
  201.  lds si,param  { load address of param }
  202.  add si,cx     { start from the top }
  203.  dec si        { minus 2 }
  204.  dec si        { ^^^^^^^ }
  205.  shr cx,1      { cx:=cx div 2 }
  206. @SM1:
  207.  lodsw         { load 1 word }
  208.  push ax       { push it }
  209.  loop @SM1      { if cx > 0 loop }
  210.  
  211.  mov ds,bx     { restore ds }
  212. @SM2:
  213.  les di,Handle { get handle }
  214.  mov ax,es     { move es to ax for compare }
  215.  cmp ax,0      { if segment is 0 then }
  216.  je @SM3       { don't push handle }
  217.  push es       { push segment }
  218.  push di       { push offset }
  219. @SM3:
  220.  mov ah,$12
  221.  mov bh,_bh
  222.  mov bl,_bl
  223.  int $15       { call dv }
  224.  
  225.  cld           { string goes forward }
  226.  mov ax,sp     { calculate the number of }
  227.  mov cx,dx     { returned parameter(s) }
  228.  sub cx,ax     { in stack }
  229.  
  230.  jcxz @SMX      { exit if none }
  231.  les di,param  { load address of param }
  232.  add di,size
  233.  shr cx,1      { cx:=cx div 2 }
  234. @SM4:
  235.  pop ax
  236.  stosw
  237.  loop @SM4
  238. @SMX:
  239. end;
  240.  
  241. function DVGetHandle( HandleType : byte ) : pointer; assembler;
  242. asm
  243.  { return object handle }
  244.  mov ah,$12
  245.  mov bh,$00
  246.  mov bl,HandleType
  247.  int $15
  248.  pop ax
  249.  pop dx
  250. end;
  251.  
  252. procedure DVSound( Handle : pointer; frequency, duration : word ); assembler;
  253. asm
  254.  { generate a sound }
  255.  mov ax,$1019
  256.  mov bx,frequency
  257.  mov cx,duration   { in 18.2 ticks/sec }
  258.  int $15
  259. end;
  260.  
  261. procedure DVError( handle : pointer; xsize, ysize : byte; msg : string; params : byte ); assembler;
  262. asm
  263.  { pop-up an error box }
  264.  {
  265.    use DVERRORxxxxx for PARAMS
  266.    example: DVError(Handle1, 80, 25, 'Don't Touch That!',
  267.                     DVErrorMouEither+DVErrorBeep);
  268.  }
  269.  mov ch,xsize
  270.  mov cl,ysize;
  271.  mov bh,params
  272.  les dx,Handle
  273.  mov dx,es
  274.  les di,msg
  275.  mov bl,es:[di]
  276.  inc di
  277.  mov ax,$101F
  278.  int $15
  279. end;
  280.  
  281. procedure DVAPILevel( major, minor : byte ); assembler;
  282. asm
  283.  { define the minimum API revision level than the program requires }
  284.  mov bh,major
  285.  mov bl,minor
  286.  mov ax,0de0bh
  287.  int 15h
  288. end;
  289.  
  290. procedure DVStream( handle : pointer; mode : byte; params : string );
  291. var
  292.  Msg : Msg_Write2;
  293. begin
  294.  { send a stream of opcode(s) }
  295.  DVArray[1]:=$1B;
  296.  DVArray[2]:=mode; { stream mode }
  297.  DVArray[3]:=length(params);
  298.  DVArray[4]:=00;
  299.  move(params[1],DVArray[5],length(params));
  300.  with Msg do
  301.   begin
  302.    Str:=@DVArray;
  303.    Len:=Length(params)+4;
  304.   end;
  305.  DVSendMsg(Handle, $05, ord((handle=nil)), sizeof(Msg), Msg);
  306.  { Meaning of "ord((handle=nil))" }
  307.  { If handle=nil then return 1 else return 0 }
  308. end;
  309.  
  310. procedure DVWrite( Handle : pointer; s : string );
  311. var
  312.  Msg : Msg_Write2;
  313. begin
  314.  { write a string }
  315.  with Msg do
  316.   begin
  317.    str:=@s[1];
  318.    len:=length(s);
  319.   end;
  320.  DVSendMsg(Handle, $05, Ord((Handle=Nil)),  Sizeof(Msg), Msg );
  321. end;
  322.  
  323. procedure DVWriteln( Handle : pointer; s : string );
  324. begin
  325.  DVWrite(Handle, s+#13#10 );
  326. end;
  327.  
  328. function DVNewWin( x, y : word ) : pointer;
  329. var
  330.  Msg : Msg_Write2_NewWin;
  331. begin
  332.  { allocate new window ( X and Y are the window's size & virtual size }
  333.  DVArray[1]:=$1B;
  334.  DVArray[2]:=$00;
  335.  DVArray[3]:=$04;
  336.  DVArray[4]:=$00;
  337.  DVArray[5]:=$E6;
  338.  DVArray[6]:=y; { Y-Size }
  339.  DVArray[7]:=x; { X-Size }
  340.  With Msg do
  341.   begin
  342.    Len:=$07;
  343.    Str:=@DVArray;
  344.    Handle:=Nil;
  345.    DVSendMsg( Nil, $05, $01, Sizeof(Msg)-4, Msg);
  346.    DVNewWin:=Handle;
  347.   end;
  348. end;
  349.  
  350. procedure DVFree( var Handle : pointer );
  351. begin
  352.  { free a handle (close a window/free a timer/etc..) }
  353.  DVSendMsg(Handle, $02, $00, $00, Handle );
  354.  Handle:=Nil;
  355. end;
  356.  
  357. function DVTimer_New : pointer;
  358. var
  359.  Handle : pointer;
  360. begin
  361.  { allocate a new timer }
  362.  DVSendMsg( Nil, $01, $0B, $00, Handle );
  363.  DVTimer_New:=Handle;
  364. end;
  365.  
  366. procedure DVTimer_Start( Handle : pointer; Time : longint );
  367. begin
  368.  { start a timer countdown (TIME is in 1/100 of a second) }
  369.  DVSendMsg(Handle, $0a, $00, sizeof(Time), Time);
  370. end;
  371.  
  372. function DVTimer_Len( Handle : pointer ) : longint;
  373. var
  374.  Len : longint;
  375. begin
  376.  { get current timer value (in 1/100 of a second) }
  377.  DVSendMsg(Handle, $09, $00, $00, Len);
  378.  DVTimer_Len:=Len;
  379. end;
  380.  
  381. { ---- Window Streams ---- }
  382.  
  383. procedure DVClear( Handle : pointer );
  384. begin
  385.  { clear window }
  386.  DVStream(Handle, WinStream, chr($E3))
  387. end;
  388.  
  389. procedure DVRedraw( Handle : pointer );
  390. begin
  391.  { redraw window }
  392.  DVStream(Handle, WinStream, chr($E4))
  393. end;
  394.  
  395. procedure DVResize( Handle : pointer; x, y : byte );
  396. begin
  397.  { resize window }
  398.  DVStream(Handle, WinStream, chr($C3)+chr(y)+chr(x));
  399. end;
  400.  
  401. procedure DVMove( Handle : pointer; x, y : shortint );
  402. begin
  403.  { move the window }
  404.  DVStream(Handle, WinStream, chr($C2)+chr(y)+chr(x))
  405. end;
  406.  
  407. procedure DVTitle( Handle : pointer; title : string );
  408. begin
  409.  { change window title }
  410.  DVStream(Handle, WinStream, chr($EF)+title[0]+title)
  411. end;
  412.  
  413. procedure DVMove2( Handle : pointer; x, y : shortint );
  414. begin
  415.  { set window position relative to the current position  }
  416.  { use negative (-1) values to move up/left }
  417.  DVStream(Handle, WinStream, chr($CA)+chr(y)+chr(x));
  418. end;
  419.  
  420. procedure DVResize2( Handle : pointer; x, y : shortint );
  421. begin
  422.  { set window size relative to the current size  }
  423.  { use negative (-1) values to shrink window }
  424.  DVStream(handle, WinStream, chr($CB)+chr(y)+chr(x));
  425. end;
  426.  
  427. procedure DVSetAttr( Handle : pointer; color : byte );
  428. begin
  429.  { set the output color }
  430.  DVStream(Handle, WinStream, chr($E2)+chr(color));
  431. end;
  432.  
  433. procedure DVFrameAttr( Handle : pointer; color : byte );
  434. begin
  435.  { set the frame color }
  436.  DVStream(Handle, WinStream, chr($ED)+chr($FF)+chr($08)+
  437.           chr(color)+chr(color)+chr(color)+chr(color)+
  438.           chr(color)+chr(color)+chr(color)+chr(color));
  439. end;
  440.  
  441. procedure DVFrameOn( Handle : pointer; b : boolean );
  442. begin
  443. { must use DVRedraw to remove the frame }
  444.  if b then DVStream(Handle, WinStream, chr($D6))
  445.   else DVStream(Handle, WinStream, chr($D7))
  446. end;
  447.  
  448. procedure DVWinUnHide( Handle : pointer );
  449. begin
  450.  { unhide a window }
  451.  DVStream(Handle, WinStream, chr($D4));
  452. end;
  453.  
  454. procedure DVWinHide( Handle : pointer );
  455. begin
  456.  { hide a window }
  457.  DVStream(Handle, WinStream, chr($D5));
  458. end;
  459.  
  460. procedure DVGotoXY( Handle : pointer; x, y : byte );
  461. begin
  462.  { positions the cursor at X, Y }
  463.  DVStream(Handle, WinStream, chr($C0)+chr(y-1)+chr(x-1));
  464. end;
  465.  
  466. procedure DVSetVirtualWinSize( Handle : pointer; x, y : byte );
  467. begin
  468.  { set window's virtual size }
  469.  DVStream(Handle, WinStream, chr($AB)+chr(x));
  470.  DVStream(Handle, WinStream, chr($AA)+chr(y));
  471. end;
  472.  
  473. { ---- Query Streams ---- }
  474.  
  475. procedure DVQSize( Handle : pointer; var x, y : byte );
  476. begin
  477.  { get the window size }
  478.  DVStream(Handle, QueryStream, chr($C3));
  479.  { result is in DVArray[6..7] }
  480.  y:=DVArray[6];
  481.  x:=DVArray[7];
  482. end;
  483.  
  484. procedure DVQPos( Handle : pointer; var x, y : shortint );
  485. begin
  486.  { get the window position }
  487.  DVStream(Handle, QueryStream, chr($C2));
  488.  { result is in DVArray[6..7] }
  489.  y:=DVArray[6];
  490.  x:=DVArray[7];
  491. end;
  492.  
  493. procedure DVQVirtualWinSize( Handle : pointer; var x, y : byte );
  494. begin
  495.  { get virtual window size }
  496.  DVStream(Handle, QueryStream, chr($AA));
  497.  Y:=DVArray[6];
  498.  DVStream(Handle, QueryStream, chr($AB));
  499.  X:=DVArray[6];
  500. end;
  501.  
  502. function DVWhereX( Handle : pointer ) : shortint;
  503. begin
  504.  { return the cursor's X position }
  505.  DVStream( Handle, QueryStream, chr($A1) );
  506.  DVWhereX:=DVArray[6];
  507. end;
  508.  
  509. function DVWhereY( Handle : pointer ) : shortint;
  510. begin
  511.  { return the cursor's Y position }
  512.  DVStream( Handle, QueryStream, chr($A0) );
  513.  DVWhereY:=DVArray[6];
  514. end;
  515.  
  516. { --- Manager Stream Procedures --- }
  517.  
  518. procedure DVAllow( Handle : pointer; command : byte );
  519. begin
  520.  { disallow a command (see constants "MStream_xxxxxx") }
  521.  DVStream(Handle, ManagerStream, chr(command));
  522. end;
  523.  
  524. procedure DVDisallow( Handle : pointer; command : byte );
  525. begin
  526.  { disallow a command (see constants "MStream_xxxxxx") }
  527.  DVStream(Handle, ManagerStream, chr(command+$20));
  528. end;
  529.  
  530. procedure DVForeOnly( Handle : pointer; b : boolean );
  531. begin
  532.  { B=TRUE if application runs on foreground only }
  533.  if b then DVStream(Handle, ManagerStream, chr($86))
  534.   else DVStream(Handle, ManagerStream, chr($87));
  535. end;
  536.  
  537. procedure DVMinWinSize( Handle : pointer; x, y : byte );
  538. begin
  539.  { define window's minimum size }
  540.  DVStream(Handle, ManagerStream, chr($88)+chr(y)+chr(x));
  541. end;
  542.  
  543. procedure DVMaxWinSize( Handle : pointer; x, y : byte );
  544. begin
  545.  { define window's maximum size }
  546.  DVStream(Handle, ManagerStream, chr($89)+chr(y)+chr(x));
  547. end;
  548.  
  549. procedure DVForceForeground( Handle : pointer );
  550. begin
  551.  { force process to run into foreground }
  552.  DVStream(Handle, ManagerStream, chr($C1));
  553. end;
  554.  
  555. procedure DVForceBackground( Handle : pointer );
  556. begin
  557.  { force process to run into background }
  558.  DVStream(Handle, ManagerStream, chr($C9));
  559. end;
  560.  
  561. procedure DVTopProcess( Handle : pointer );
  562. begin
  563.  { make current window topmost in process }
  564.  DVStream( Handle, ManagerStream, chr($C2) );
  565. end;
  566.  
  567. procedure DVBottomProcess( Handle : pointer );
  568. begin
  569.  { make current window bottom-most in process }
  570.  DVStream( Handle, ManagerStream, chr($CA) );
  571. end;
  572.  
  573.  
  574. end.
  575.